/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow5Stride2Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Forward>;
TYPED_TEST_SUITE(AvgWindow5Stride2Forward, GTestTypePairs);
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9.,  10., 12., 13., 16., 17.,
                                         19., 20., 30., 31., 33., 34.,
                                         37., 38., 40., 41.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 31., 33.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 19., 20., 23., 24., 25., 26., 31., 32., 33.,
      34., 37., 38., 39., 40., 59., 60., 61., 62., 65., 66.,
      67., 68., 73., 74., 75., 76., 79., 80., 81., 82.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 37., 38.,
                                         61., 62., 65., 66.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,
      48.,  49.,  50.,  51.,  52.,  61.,  62.,  63.,  64.,  65.,  66.,
      67.,  68.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  117.,
      118., 119., 120., 121., 122., 123., 124., 129., 130., 131., 132.,
      133., 134., 135., 136., 145., 146., 147., 148., 149., 150., 151.,
      152., 157., 158., 159., 160., 161., 162., 163., 164.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65.,  66.,  67.,  68.,  73.,  74.,
                                         75.,  76.,  121., 122., 123., 124.,
                                         129., 130., 131., 132.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10.5, 12., 14.,  15., 18.5, 20.,
                                         22.,  23., 34.5, 36., 38.,  39.,
                                         42.5, 44., 46.,  47.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 35., 37.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20., 21., 23., 24., 27., 28., 29., 30., 36., 37., 39.,
      40., 43., 44., 45., 46., 68., 69., 71., 72., 75., 76.,
      77., 78., 84., 85., 87., 88., 91., 92., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 41., 42.,
                                         69., 70., 73., 74.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39.,  40.,  41.,  42.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,
      56.,  57.,  58.,  59.,  60.,  71.,  72.,  73.,  74.,  77.,  78.,
      79.,  80.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  135.,
      136., 137., 138., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 167., 168., 169., 170., 173., 174., 175.,
      176., 181., 182., 183., 184., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  75.,  76.,  81.,  82.,
                                         83.,  84.,  137., 138., 139., 140.,
                                         145., 146., 147., 148.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12.5, 14.,  16., 18.,  19., 22.5, 24.,
                                         26.,  28.,  29., 42.5, 44., 46.,  48.,
                                         49.,  52.5, 54., 56.,  58., 59.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23., 25., 27., 43., 45., 47.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  25.,  27.,  28.,  31.,  32.,  35.,  36.,  37.,  38.,
      44.,  45.,  47.,  48.,  51.,  52.,  55.,  56.,  57.,  58.,
      84.,  85.,  87.,  88.,  91.,  92.,  95.,  96.,  97.,  98.,
      104., 105., 107., 108., 111., 112., 115., 116., 117., 118.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45., 46., 49., 50., 53., 54.,
                                         85., 86., 89., 90., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  53.,  54.,  55.,  56.,  61.,  62.,  63.,  64.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  87.,  88.,  89.,  90.,
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      113., 114., 115., 116., 167., 168., 169., 170., 173., 174., 175., 176.,
      181., 182., 183., 184., 189., 190., 191., 192., 193., 194., 195., 196.,
      207., 208., 209., 210., 213., 214., 215., 216., 221., 222., 223., 224.,
      229., 230., 231., 232., 233., 234., 235., 236.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  91.,  92.,  97.,  98.,  99.,  100., 105., 106., 107., 108.,
      169., 170., 171., 172., 177., 178., 179., 180., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12.5, 13.5, 15.5, 16.5, 23., 24.,
                                         26.,  27.,  37.,  38.,  40., 41.,
                                         44.,  45.,  47.,  48.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 31., 33.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24., 25., 26., 27., 30., 31., 32., 33., 45., 46., 47.,
      48., 51., 52., 53., 54., 73., 74., 75., 76., 79., 80.,
      81., 82., 87., 88., 89., 90., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 37., 38.,
                                         61., 62., 65., 66.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  59.,  60.,  61.,
      62.,  63.,  64.,  65.,  66.,  89.,  90.,  91.,  92.,  93.,  94.,
      95.,  96.,  101., 102., 103., 104., 105., 106., 107., 108., 145.,
      146., 147., 148., 149., 150., 151., 152., 157., 158., 159., 160.,
      161., 162., 163., 164., 173., 174., 175., 176., 177., 178., 179.,
      180., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65.,  66.,  67.,  68.,  73.,  74.,
                                         75.,  76.,  121., 122., 123., 124.,
                                         129., 130., 131., 132.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14.5, 16., 18.,  19., 26.5, 28.,
                                         30.,  31., 42.5, 44., 46.,  47.,
                                         50.5, 52., 54.,  55.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 35., 37.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28., 29., 31.,  32.,  35.,  36.,  37.,  38.,  52.,  53., 55.,
      56., 59., 60.,  61.,  62.,  84.,  85.,  87.,  88.,  91., 92.,
      93., 94., 100., 101., 103., 104., 107., 108., 109., 110.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 41., 42.,
                                         69., 70., 73., 74.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  61.,  62.,  63.,  64.,  69.,  70.,  71.,
      72.,  73.,  74.,  75.,  76.,  103., 104., 105., 106., 109., 110.,
      111., 112., 117., 118., 119., 120., 121., 122., 123., 124., 167.,
      168., 169., 170., 173., 174., 175., 176., 181., 182., 183., 184.,
      185., 186., 187., 188., 199., 200., 201., 202., 205., 206., 207.,
      208., 213., 214., 215., 216., 217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  75.,  76.,  81.,  82.,
                                         83.,  84.,  137., 138., 139., 140.,
                                         145., 146., 147., 148.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17.5, 19.,  21., 23.,  24., 32.5, 34.,
                                         36.,  38.,  39., 52.5, 54., 56.,  58.,
                                         59.,  62.5, 64., 66.,  68., 69.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23., 25., 27., 43., 45., 47.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,
      64.,  65.,  67.,  68.,  71.,  72.,  75.,  76.,  77.,  78.,
      104., 105., 107., 108., 111., 112., 115., 116., 117., 118.,
      124., 125., 127., 128., 131., 132., 135., 136., 137., 138.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45., 46., 49., 50., 53., 54.,
                                         85., 86., 89., 90., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  127., 128., 129., 130.,
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 207., 208., 209., 210., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      247., 248., 249., 250., 253., 254., 255., 256., 261., 262., 263., 264.,
      269., 270., 271., 272., 273., 274., 275., 276.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  91.,  92.,  97.,  98.,  99.,  100., 105., 106., 107., 108.,
      169., 170., 171., 172., 177., 178., 179., 180., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12.5, 13.5, 15.5, 16.5, 23., 24., 26.,
                                         27.,  37.,  38.,  40.,  41., 51., 52.,
                                         54.,  55.,  58.,  59.,  61., 62.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 31., 33., 45., 47.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  25.,  26.,  27.,  30.,  31.,  32.,  33.,  45.,  46.,
      47.,  48.,  51.,  52.,  53.,  54.,  73.,  74.,  75.,  76.,
      79.,  80.,  81.,  82.,  101., 102., 103., 104., 107., 108.,
      109., 110., 115., 116., 117., 118., 121., 122., 123., 124.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 37., 38., 61., 62.,
                                         65., 66., 89., 90., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  59.,  60.,  61.,  62.,
      63.,  64.,  65.,  66.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 145., 146., 147., 148.,
      149., 150., 151., 152., 157., 158., 159., 160., 161., 162., 163., 164.,
      201., 202., 203., 204., 205., 206., 207., 208., 213., 214., 215., 216.,
      217., 218., 219., 220., 229., 230., 231., 232., 233., 234., 235., 236.,
      241., 242., 243., 244., 245., 246., 247., 248.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  121., 122., 123., 124.,
      129., 130., 131., 132., 177., 178., 179., 180., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14.5, 16.,  18.,  19., 26.5, 28.,  30.,
                                         31.,  42.5, 44.,  46., 47.,  58.5, 60.,
                                         62.,  63.,  66.5, 68., 70.,  71.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 35., 37., 51., 53.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  31.,  32.,  35.,  36.,  37.,  38.,  52.,  53.,
      55.,  56.,  59.,  60.,  61.,  62.,  84.,  85.,  87.,  88.,
      91.,  92.,  93.,  94.,  116., 117., 119., 120., 123., 124.,
      125., 126., 132., 133., 135., 136., 139., 140., 141., 142.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 41.,  42.,  69.,  70.,
                                         73., 74., 101., 102., 105., 106.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  61.,  62.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  103., 104., 105., 106., 109., 110., 111., 112.,
      117., 118., 119., 120., 121., 122., 123., 124., 167., 168., 169., 170.,
      173., 174., 175., 176., 181., 182., 183., 184., 185., 186., 187., 188.,
      231., 232., 233., 234., 237., 238., 239., 240., 245., 246., 247., 248.,
      249., 250., 251., 252., 263., 264., 265., 266., 269., 270., 271., 272.,
      277., 278., 279., 280., 281., 282., 283., 284.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  137., 138., 139., 140.,
      145., 146., 147., 148., 201., 202., 203., 204., 209., 210., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5, 19., 21.,  23., 24., 32.5, 34., 36.,  38., 39., 52.5, 54., 56.,
      58.,  59., 72.5, 74., 76., 78.,  79., 82.5, 84., 86., 88.,  89.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23., 25., 27., 43., 45.,
                                         47., 63., 65., 67.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,
      64.,  65.,  67.,  68.,  71.,  72.,  75.,  76.,  77.,  78.,
      104., 105., 107., 108., 111., 112., 115., 116., 117., 118.,
      144., 145., 147., 148., 151., 152., 155., 156., 157., 158.,
      164., 165., 167., 168., 171., 172., 175., 176., 177., 178.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45.,  46.,  49.,  50.,  53.,  54.,
                                         85.,  86.,  89.,  90.,  93.,  94.,
                                         125., 126., 129., 130., 133., 134.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  127., 128., 129., 130.,
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 207., 208., 209., 210., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      287., 288., 289., 290., 293., 294., 295., 296., 301., 302., 303., 304.,
      309., 310., 311., 312., 313., 314., 315., 316., 327., 328., 329., 330.,
      333., 334., 335., 336., 341., 342., 343., 344., 349., 350., 351., 352.,
      353., 354., 355., 356.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  91.,  92.,  97.,  98.,  99.,  100., 105., 106., 107., 108.,
      169., 170., 171., 172., 177., 178., 179., 180., 185., 186., 187., 188.,
      249., 250., 251., 252., 257., 258., 259., 260., 265., 266., 267., 268.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,   10.,  12.,  13.,  16.,  17.,  19.,  20.,  30.,  31.,  33.,  34.,
      37.,  38.,  40.,  41.,  58.,  59.,  61.,  62.,  65.,  66.,  68.,  69.,
      79.,  80.,  82.,  83.,  86.,  87.,  89.,  90.,  107., 108., 110., 111.,
      114., 115., 117., 118., 128., 129., 131., 132., 135., 136., 138., 139.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 31.,  33.,  66.,  68.,
                                         80., 82., 115., 117., 129., 131.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  20.,  23.,  24.,  25.,  26.,  31.,  32.,  33.,  34.,
      37.,  38.,  39.,  40.,  59.,  60.,  61.,  62.,  65.,  66.,  67.,  68.,
      73.,  74.,  75.,  76.,  79.,  80.,  81.,  82.,  115., 116., 117., 118.,
      121., 122., 123., 124., 129., 130., 131., 132., 135., 136., 137., 138.,
      157., 158., 159., 160., 163., 164., 165., 166., 171., 172., 173., 174.,
      177., 178., 179., 180., 213., 214., 215., 216., 219., 220., 221., 222.,
      227., 228., 229., 230., 233., 234., 235., 236., 255., 256., 257., 258.,
      261., 262., 263., 264., 269., 270., 271., 272., 275., 276., 277., 278.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  37.,  38.,  61.,  62.,  65.,  66.,  131., 132., 135., 136.,
      159., 160., 163., 164., 229., 230., 233., 234., 257., 258., 261., 262.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  117., 118., 119., 120.,
      121., 122., 123., 124., 129., 130., 131., 132., 133., 134., 135., 136.,
      145., 146., 147., 148., 149., 150., 151., 152., 157., 158., 159., 160.,
      161., 162., 163., 164., 229., 230., 231., 232., 233., 234., 235., 236.,
      241., 242., 243., 244., 245., 246., 247., 248., 257., 258., 259., 260.,
      261., 262., 263., 264., 269., 270., 271., 272., 273., 274., 275., 276.,
      313., 314., 315., 316., 317., 318., 319., 320., 325., 326., 327., 328.,
      329., 330., 331., 332., 341., 342., 343., 344., 345., 346., 347., 348.,
      353., 354., 355., 356., 357., 358., 359., 360., 425., 426., 427., 428.,
      429., 430., 431., 432., 437., 438., 439., 440., 441., 442., 443., 444.,
      453., 454., 455., 456., 457., 458., 459., 460., 465., 466., 467., 468.,
      469., 470., 471., 472., 509., 510., 511., 512., 513., 514., 515., 516.,
      521., 522., 523., 524., 525., 526., 527., 528., 537., 538., 539., 540.,
      541., 542., 543., 544., 549., 550., 551., 552., 553., 554., 555., 556.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  121., 122., 123., 124.,
      129., 130., 131., 132., 261., 262., 263., 264., 269., 270., 271., 272.,
      317., 318., 319., 320., 325., 326., 327., 328., 457., 458., 459., 460.,
      465., 466., 467., 468., 513., 514., 515., 516., 521., 522., 523., 524.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10.5,  12.,  14.,   15.,  18.5,  20.,  22.,   23.,  34.5, 36.,
      38.,   39.,  42.5,  44.,  46.,   47.,  66.5,  68.,  70.,  71.,
      74.5,  76.,  78.,   79.,  90.5,  92.,  94.,   95.,  98.5, 100.,
      102.,  103., 122.5, 124., 126.,  127., 130.5, 132., 134., 135.,
      146.5, 148., 150.,  151., 154.5, 156., 158.,  159.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 35.,  37.,  75.,  77.,
                                         91., 93., 131., 133., 147., 149.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20.,  21.,  23.,  24.,  27.,  28.,  29.,  30.,  36.,  37.,  39.,  40.,
      43.,  44.,  45.,  46.,  68.,  69.,  71.,  72.,  75.,  76.,  77.,  78.,
      84.,  85.,  87.,  88.,  91.,  92.,  93.,  94.,  132., 133., 135., 136.,
      139., 140., 141., 142., 148., 149., 151., 152., 155., 156., 157., 158.,
      180., 181., 183., 184., 187., 188., 189., 190., 196., 197., 199., 200.,
      203., 204., 205., 206., 244., 245., 247., 248., 251., 252., 253., 254.,
      260., 261., 263., 264., 267., 268., 269., 270., 292., 293., 295., 296.,
      299., 300., 301., 302., 308., 309., 311., 312., 315., 316., 317., 318.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  69.,  70.,  73.,  74.,  149., 150., 153., 154.,
      181., 182., 185., 186., 261., 262., 265., 266., 293., 294., 297., 298.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39.,  40.,  41.,  42.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  71.,  72.,  73.,  74.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  135., 136., 137., 138.,
      141., 142., 143., 144., 149., 150., 151., 152., 153., 154., 155., 156.,
      167., 168., 169., 170., 173., 174., 175., 176., 181., 182., 183., 184.,
      185., 186., 187., 188., 263., 264., 265., 266., 269., 270., 271., 272.,
      277., 278., 279., 280., 281., 282., 283., 284., 295., 296., 297., 298.,
      301., 302., 303., 304., 309., 310., 311., 312., 313., 314., 315., 316.,
      359., 360., 361., 362., 365., 366., 367., 368., 373., 374., 375., 376.,
      377., 378., 379., 380., 391., 392., 393., 394., 397., 398., 399., 400.,
      405., 406., 407., 408., 409., 410., 411., 412., 487., 488., 489., 490.,
      493., 494., 495., 496., 501., 502., 503., 504., 505., 506., 507., 508.,
      519., 520., 521., 522., 525., 526., 527., 528., 533., 534., 535., 536.,
      537., 538., 539., 540., 583., 584., 585., 586., 589., 590., 591., 592.,
      597., 598., 599., 600., 601., 602., 603., 604., 615., 616., 617., 618.,
      621., 622., 623., 624., 629., 630., 631., 632., 633., 634., 635., 636.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  137., 138., 139., 140.,
      145., 146., 147., 148., 297., 298., 299., 300., 305., 306., 307., 308.,
      361., 362., 363., 364., 369., 370., 371., 372., 521., 522., 523., 524.,
      529., 530., 531., 532., 585., 586., 587., 588., 593., 594., 595., 596.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12.5,  14.,  16.,  18.,  19.,  22.5,  24.,  26.,  28.,  29.,
      42.5,  44.,  46.,  48.,  49.,  52.5,  54.,  56.,  58.,  59.,
      82.5,  84.,  86.,  88.,  89.,  92.5,  94.,  96.,  98.,  99.,
      112.5, 114., 116., 118., 119., 122.5, 124., 126., 128., 129.,
      152.5, 154., 156., 158., 159., 162.5, 164., 166., 168., 169.,
      182.5, 184., 186., 188., 189., 192.5, 194., 196., 198., 199.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23.,  25.,  27.,  43.,  45.,  47.,
                                         93.,  95.,  97.,  113., 115., 117.,
                                         163., 165., 167., 183., 185., 187.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  25.,  27.,  28.,  31.,  32.,  35.,  36.,  37.,  38.,  44.,  45.,
      47.,  48.,  51.,  52.,  55.,  56.,  57.,  58.,  84.,  85.,  87.,  88.,
      91.,  92.,  95.,  96.,  97.,  98.,  104., 105., 107., 108., 111., 112.,
      115., 116., 117., 118., 164., 165., 167., 168., 171., 172., 175., 176.,
      177., 178., 184., 185., 187., 188., 191., 192., 195., 196., 197., 198.,
      224., 225., 227., 228., 231., 232., 235., 236., 237., 238., 244., 245.,
      247., 248., 251., 252., 255., 256., 257., 258., 304., 305., 307., 308.,
      311., 312., 315., 316., 317., 318., 324., 325., 327., 328., 331., 332.,
      335., 336., 337., 338., 364., 365., 367., 368., 371., 372., 375., 376.,
      377., 378., 384., 385., 387., 388., 391., 392., 395., 396., 397., 398.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  49.,  50.,  53.,  54.,  85.,  86.,  89.,  90.,  93.,  94.,
      185., 186., 189., 190., 193., 194., 225., 226., 229., 230., 233., 234.,
      325., 326., 329., 330., 333., 334., 365., 366., 369., 370., 373., 374.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  53.,  54.,  55.,  56.,  61.,  62.,  63.,  64.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  87.,  88.,  89.,  90.,
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      113., 114., 115., 116., 167., 168., 169., 170., 173., 174., 175., 176.,
      181., 182., 183., 184., 189., 190., 191., 192., 193., 194., 195., 196.,
      207., 208., 209., 210., 213., 214., 215., 216., 221., 222., 223., 224.,
      229., 230., 231., 232., 233., 234., 235., 236., 327., 328., 329., 330.,
      333., 334., 335., 336., 341., 342., 343., 344., 349., 350., 351., 352.,
      353., 354., 355., 356., 367., 368., 369., 370., 373., 374., 375., 376.,
      381., 382., 383., 384., 389., 390., 391., 392., 393., 394., 395., 396.,
      447., 448., 449., 450., 453., 454., 455., 456., 461., 462., 463., 464.,
      469., 470., 471., 472., 473., 474., 475., 476., 487., 488., 489., 490.,
      493., 494., 495., 496., 501., 502., 503., 504., 509., 510., 511., 512.,
      513., 514., 515., 516., 607., 608., 609., 610., 613., 614., 615., 616.,
      621., 622., 623., 624., 629., 630., 631., 632., 633., 634., 635., 636.,
      647., 648., 649., 650., 653., 654., 655., 656., 661., 662., 663., 664.,
      669., 670., 671., 672., 673., 674., 675., 676., 727., 728., 729., 730.,
      733., 734., 735., 736., 741., 742., 743., 744., 749., 750., 751., 752.,
      753., 754., 755., 756., 767., 768., 769., 770., 773., 774., 775., 776.,
      781., 782., 783., 784., 789., 790., 791., 792., 793., 794., 795., 796.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  91.,  92.,  97.,  98.,  99.,  100., 105., 106., 107., 108.,
      169., 170., 171., 172., 177., 178., 179., 180., 185., 186., 187., 188.,
      369., 370., 371., 372., 377., 378., 379., 380., 385., 386., 387., 388.,
      449., 450., 451., 452., 457., 458., 459., 460., 465., 466., 467., 468.,
      649., 650., 651., 652., 657., 658., 659., 660., 665., 666., 667., 668.,
      729., 730., 731., 732., 737., 738., 739., 740., 745., 746., 747., 748.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12.5, 13.5, 15.5,  16.5,  23.,   24.,   26.,  27.,  37.,  38.,
      40.,  41.,  44.,   45.,   47.,   48.,   68.5, 69.5, 71.5, 72.5,
      79.,  80.,  82.,   83.,   93.,   94.,   96.,  97.,  100., 101.,
      103., 104., 124.5, 125.5, 127.5, 128.5, 135., 136., 138., 139.,
      149., 150., 152.,  153.,  156.,  157.,  159., 160.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 31.,  33.,  73.,  75.,
                                         87., 89., 129., 131., 143., 145.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  25.,  26.,  27.,  30.,  31.,  32.,  33.,  45.,  46.,  47.,  48.,
      51.,  52.,  53.,  54.,  73.,  74.,  75.,  76.,  79.,  80.,  81.,  82.,
      87.,  88.,  89.,  90.,  93.,  94.,  95.,  96.,  136., 137., 138., 139.,
      142., 143., 144., 145., 157., 158., 159., 160., 163., 164., 165., 166.,
      185., 186., 187., 188., 191., 192., 193., 194., 199., 200., 201., 202.,
      205., 206., 207., 208., 248., 249., 250., 251., 254., 255., 256., 257.,
      269., 270., 271., 272., 275., 276., 277., 278., 297., 298., 299., 300.,
      303., 304., 305., 306., 311., 312., 313., 314., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  37.,  38.,  61.,  62.,  65.,  66.,  145., 146., 149., 150.,
      173., 174., 177., 178., 257., 258., 261., 262., 285., 286., 289., 290.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  59.,  60.,  61.,  62.,
      63.,  64.,  65.,  66.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 145., 146., 147., 148.,
      149., 150., 151., 152., 157., 158., 159., 160., 161., 162., 163., 164.,
      173., 174., 175., 176., 177., 178., 179., 180., 185., 186., 187., 188.,
      189., 190., 191., 192., 271., 272., 273., 274., 275., 276., 277., 278.,
      283., 284., 285., 286., 287., 288., 289., 290., 313., 314., 315., 316.,
      317., 318., 319., 320., 325., 326., 327., 328., 329., 330., 331., 332.,
      369., 370., 371., 372., 373., 374., 375., 376., 381., 382., 383., 384.,
      385., 386., 387., 388., 397., 398., 399., 400., 401., 402., 403., 404.,
      409., 410., 411., 412., 413., 414., 415., 416., 495., 496., 497., 498.,
      499., 500., 501., 502., 507., 508., 509., 510., 511., 512., 513., 514.,
      537., 538., 539., 540., 541., 542., 543., 544., 549., 550., 551., 552.,
      553., 554., 555., 556., 593., 594., 595., 596., 597., 598., 599., 600.,
      605., 606., 607., 608., 609., 610., 611., 612., 621., 622., 623., 624.,
      625., 626., 627., 628., 633., 634., 635., 636., 637., 638., 639., 640.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  121., 122., 123., 124.,
      129., 130., 131., 132., 289., 290., 291., 292., 297., 298., 299., 300.,
      345., 346., 347., 348., 353., 354., 355., 356., 513., 514., 515., 516.,
      521., 522., 523., 524., 569., 570., 571., 572., 577., 578., 579., 580.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5,  16.,  18.,   19.,  26.5,  28.,  30.,   31.,  42.5,  44.,
      46.,   47.,  50.5,  52.,  54.,   55.,  78.5,  80.,  82.,   83.,
      90.5,  92.,  94.,   95.,  106.5, 108., 110.,  111., 114.5, 116.,
      118.,  119., 142.5, 144., 146.,  147., 154.5, 156., 158.,  159.,
      170.5, 172., 174.,  175., 178.5, 180., 182.,  183.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21.,  35.,  37.,  83.,  85.,
                                         99., 101., 147., 149., 163., 165.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  31.,  32.,  35.,  36.,  37.,  38.,  52.,  53.,  55.,  56.,
      59.,  60.,  61.,  62.,  84.,  85.,  87.,  88.,  91.,  92.,  93.,  94.,
      100., 101., 103., 104., 107., 108., 109., 110., 156., 157., 159., 160.,
      163., 164., 165., 166., 180., 181., 183., 184., 187., 188., 189., 190.,
      212., 213., 215., 216., 219., 220., 221., 222., 228., 229., 231., 232.,
      235., 236., 237., 238., 284., 285., 287., 288., 291., 292., 293., 294.,
      308., 309., 311., 312., 315., 316., 317., 318., 340., 341., 343., 344.,
      347., 348., 349., 350., 356., 357., 359., 360., 363., 364., 365., 366.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  69.,  70.,  73.,  74.,  165., 166., 169., 170.,
      197., 198., 201., 202., 293., 294., 297., 298., 325., 326., 329., 330.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  61.,  62.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  103., 104., 105., 106., 109., 110., 111., 112.,
      117., 118., 119., 120., 121., 122., 123., 124., 167., 168., 169., 170.,
      173., 174., 175., 176., 181., 182., 183., 184., 185., 186., 187., 188.,
      199., 200., 201., 202., 205., 206., 207., 208., 213., 214., 215., 216.,
      217., 218., 219., 220., 311., 312., 313., 314., 317., 318., 319., 320.,
      325., 326., 327., 328., 329., 330., 331., 332., 359., 360., 361., 362.,
      365., 366., 367., 368., 373., 374., 375., 376., 377., 378., 379., 380.,
      423., 424., 425., 426., 429., 430., 431., 432., 437., 438., 439., 440.,
      441., 442., 443., 444., 455., 456., 457., 458., 461., 462., 463., 464.,
      469., 470., 471., 472., 473., 474., 475., 476., 567., 568., 569., 570.,
      573., 574., 575., 576., 581., 582., 583., 584., 585., 586., 587., 588.,
      615., 616., 617., 618., 621., 622., 623., 624., 629., 630., 631., 632.,
      633., 634., 635., 636., 679., 680., 681., 682., 685., 686., 687., 688.,
      693., 694., 695., 696., 697., 698., 699., 700., 711., 712., 713., 714.,
      717., 718., 719., 720., 725., 726., 727., 728., 729., 730., 731., 732.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  137., 138., 139., 140.,
      145., 146., 147., 148., 329., 330., 331., 332., 337., 338., 339., 340.,
      393., 394., 395., 396., 401., 402., 403., 404., 585., 586., 587., 588.,
      593., 594., 595., 596., 649., 650., 651., 652., 657., 658., 659., 660.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5,  19.,  21.,  23.,  24.,  32.5,  34.,  36.,  38.,  39.,
      52.5,  54.,  56.,  58.,  59.,  62.5,  64.,  66.,  68.,  69.,
      97.5,  99.,  101., 103., 104., 112.5, 114., 116., 118., 119.,
      132.5, 134., 136., 138., 139., 142.5, 144., 146., 148., 149.,
      177.5, 179., 181., 183., 184., 192.5, 194., 196., 198., 199.,
      212.5, 214., 216., 218., 219., 222.5, 224., 226., 228., 229.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23.,  25.,  27.,  43.,  45.,  47.,
                                         103., 105., 107., 123., 125., 127.,
                                         183., 185., 187., 203., 205., 207.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,  64.,  65.,
      67.,  68.,  71.,  72.,  75.,  76.,  77.,  78.,  104., 105., 107., 108.,
      111., 112., 115., 116., 117., 118., 124., 125., 127., 128., 131., 132.,
      135., 136., 137., 138., 194., 195., 197., 198., 201., 202., 205., 206.,
      207., 208., 224., 225., 227., 228., 231., 232., 235., 236., 237., 238.,
      264., 265., 267., 268., 271., 272., 275., 276., 277., 278., 284., 285.,
      287., 288., 291., 292., 295., 296., 297., 298., 354., 355., 357., 358.,
      361., 362., 365., 366., 367., 368., 384., 385., 387., 388., 391., 392.,
      395., 396., 397., 398., 424., 425., 427., 428., 431., 432., 435., 436.,
      437., 438., 444., 445., 447., 448., 451., 452., 455., 456., 457., 458.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  49.,  50.,  53.,  54.,  85.,  86.,  89.,  90.,  93.,  94.,
      205., 206., 209., 210., 213., 214., 245., 246., 249., 250., 253., 254.,
      365., 366., 369., 370., 373., 374., 405., 406., 409., 410., 413., 414.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  127., 128., 129., 130.,
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 207., 208., 209., 210., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      247., 248., 249., 250., 253., 254., 255., 256., 261., 262., 263., 264.,
      269., 270., 271., 272., 273., 274., 275., 276., 387., 388., 389., 390.,
      393., 394., 395., 396., 401., 402., 403., 404., 409., 410., 411., 412.,
      413., 414., 415., 416., 447., 448., 449., 450., 453., 454., 455., 456.,
      461., 462., 463., 464., 469., 470., 471., 472., 473., 474., 475., 476.,
      527., 528., 529., 530., 533., 534., 535., 536., 541., 542., 543., 544.,
      549., 550., 551., 552., 553., 554., 555., 556., 567., 568., 569., 570.,
      573., 574., 575., 576., 581., 582., 583., 584., 589., 590., 591., 592.,
      593., 594., 595., 596., 707., 708., 709., 710., 713., 714., 715., 716.,
      721., 722., 723., 724., 729., 730., 731., 732., 733., 734., 735., 736.,
      767., 768., 769., 770., 773., 774., 775., 776., 781., 782., 783., 784.,
      789., 790., 791., 792., 793., 794., 795., 796., 847., 848., 849., 850.,
      853., 854., 855., 856., 861., 862., 863., 864., 869., 870., 871., 872.,
      873., 874., 875., 876., 887., 888., 889., 890., 893., 894., 895., 896.,
      901., 902., 903., 904., 909., 910., 911., 912., 913., 914., 915., 916.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  91.,  92.,  97.,  98.,  99.,  100., 105., 106., 107., 108.,
      169., 170., 171., 172., 177., 178., 179., 180., 185., 186., 187., 188.,
      409., 410., 411., 412., 417., 418., 419., 420., 425., 426., 427., 428.,
      489., 490., 491., 492., 497., 498., 499., 500., 505., 506., 507., 508.,
      729., 730., 731., 732., 737., 738., 739., 740., 745., 746., 747., 748.,
      809., 810., 811., 812., 817., 818., 819., 820., 825., 826., 827., 828.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12.5,  13.5,  15.5,  16.5,  23.,  24.,  26.,  27.,  37.,  38.,
      40.,   41.,   51.,   52.,   54.,  55.,  58.,  59.,  61.,  62.,
      82.5,  83.5,  85.5,  86.5,  93.,  94.,  96.,  97.,  107., 108.,
      110.,  111.,  121.,  122.,  124., 125., 128., 129., 131., 132.,
      152.5, 153.5, 155.5, 156.5, 163., 164., 166., 167., 177., 178.,
      180.,  181.,  191.,  192.,  194., 195., 198., 199., 201., 202.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17.,  19.,  31.,  33.,  45.,  47.,
                                         87.,  89.,  101., 103., 115., 117.,
                                         157., 159., 171., 173., 185., 187.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  25.,  26.,  27.,  30.,  31.,  32.,  33.,  45.,  46.,  47.,  48.,
      51.,  52.,  53.,  54.,  73.,  74.,  75.,  76.,  79.,  80.,  81.,  82.,
      101., 102., 103., 104., 107., 108., 109., 110., 115., 116., 117., 118.,
      121., 122., 123., 124., 164., 165., 166., 167., 170., 171., 172., 173.,
      185., 186., 187., 188., 191., 192., 193., 194., 213., 214., 215., 216.,
      219., 220., 221., 222., 241., 242., 243., 244., 247., 248., 249., 250.,
      255., 256., 257., 258., 261., 262., 263., 264., 304., 305., 306., 307.,
      310., 311., 312., 313., 325., 326., 327., 328., 331., 332., 333., 334.,
      353., 354., 355., 356., 359., 360., 361., 362., 381., 382., 383., 384.,
      387., 388., 389., 390., 395., 396., 397., 398., 401., 402., 403., 404.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  37.,  38.,  61.,  62.,  65.,  66.,  89.,  90.,  93.,  94.,
      173., 174., 177., 178., 201., 202., 205., 206., 229., 230., 233., 234.,
      313., 314., 317., 318., 341., 342., 345., 346., 369., 370., 373., 374.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  59.,  60.,  61.,  62.,
      63.,  64.,  65.,  66.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 145., 146., 147., 148.,
      149., 150., 151., 152., 157., 158., 159., 160., 161., 162., 163., 164.,
      201., 202., 203., 204., 205., 206., 207., 208., 213., 214., 215., 216.,
      217., 218., 219., 220., 229., 230., 231., 232., 233., 234., 235., 236.,
      241., 242., 243., 244., 245., 246., 247., 248., 327., 328., 329., 330.,
      331., 332., 333., 334., 339., 340., 341., 342., 343., 344., 345., 346.,
      369., 370., 371., 372., 373., 374., 375., 376., 381., 382., 383., 384.,
      385., 386., 387., 388., 425., 426., 427., 428., 429., 430., 431., 432.,
      437., 438., 439., 440., 441., 442., 443., 444., 481., 482., 483., 484.,
      485., 486., 487., 488., 493., 494., 495., 496., 497., 498., 499., 500.,
      509., 510., 511., 512., 513., 514., 515., 516., 521., 522., 523., 524.,
      525., 526., 527., 528., 607., 608., 609., 610., 611., 612., 613., 614.,
      619., 620., 621., 622., 623., 624., 625., 626., 649., 650., 651., 652.,
      653., 654., 655., 656., 661., 662., 663., 664., 665., 666., 667., 668.,
      705., 706., 707., 708., 709., 710., 711., 712., 717., 718., 719., 720.,
      721., 722., 723., 724., 761., 762., 763., 764., 765., 766., 767., 768.,
      773., 774., 775., 776., 777., 778., 779., 780., 789., 790., 791., 792.,
      793., 794., 795., 796., 801., 802., 803., 804., 805., 806., 807., 808.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  121., 122., 123., 124.,
      129., 130., 131., 132., 177., 178., 179., 180., 185., 186., 187., 188.,
      345., 346., 347., 348., 353., 354., 355., 356., 401., 402., 403., 404.,
      409., 410., 411., 412., 457., 458., 459., 460., 465., 466., 467., 468.,
      625., 626., 627., 628., 633., 634., 635., 636., 681., 682., 683., 684.,
      689., 690., 691., 692., 737., 738., 739., 740., 745., 746., 747., 748.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5,  16.,  18.,   19.,  26.5,  28.,  30.,   31.,  42.5,  44.,
      46.,   47.,  58.5,  60.,  62.,   63.,  66.5,  68.,  70.,   71.,
      94.5,  96.,  98.,   99.,  106.5, 108., 110.,  111., 122.5, 124.,
      126.,  127., 138.5, 140., 142.,  143., 146.5, 148., 150.,  151.,
      174.5, 176., 178.,  179., 186.5, 188., 190.,  191., 202.5, 204.,
      206.,  207., 218.5, 220., 222.,  223., 226.5, 228., 230.,  231.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19.,  21.,  35.,  37.,  51.,  53.,
                                         99.,  101., 115., 117., 131., 133.,
                                         179., 181., 195., 197., 211., 213.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  31.,  32.,  35.,  36.,  37.,  38.,  52.,  53.,  55.,  56.,
      59.,  60.,  61.,  62.,  84.,  85.,  87.,  88.,  91.,  92.,  93.,  94.,
      116., 117., 119., 120., 123., 124., 125., 126., 132., 133., 135., 136.,
      139., 140., 141., 142., 188., 189., 191., 192., 195., 196., 197., 198.,
      212., 213., 215., 216., 219., 220., 221., 222., 244., 245., 247., 248.,
      251., 252., 253., 254., 276., 277., 279., 280., 283., 284., 285., 286.,
      292., 293., 295., 296., 299., 300., 301., 302., 348., 349., 351., 352.,
      355., 356., 357., 358., 372., 373., 375., 376., 379., 380., 381., 382.,
      404., 405., 407., 408., 411., 412., 413., 414., 436., 437., 439., 440.,
      443., 444., 445., 446., 452., 453., 455., 456., 459., 460., 461., 462.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  69.,  70.,  73.,  74.,  101., 102., 105., 106.,
      197., 198., 201., 202., 229., 230., 233., 234., 261., 262., 265., 266.,
      357., 358., 361., 362., 389., 390., 393., 394., 421., 422., 425., 426.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  61.,  62.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  103., 104., 105., 106., 109., 110., 111., 112.,
      117., 118., 119., 120., 121., 122., 123., 124., 167., 168., 169., 170.,
      173., 174., 175., 176., 181., 182., 183., 184., 185., 186., 187., 188.,
      231., 232., 233., 234., 237., 238., 239., 240., 245., 246., 247., 248.,
      249., 250., 251., 252., 263., 264., 265., 266., 269., 270., 271., 272.,
      277., 278., 279., 280., 281., 282., 283., 284., 375., 376., 377., 378.,
      381., 382., 383., 384., 389., 390., 391., 392., 393., 394., 395., 396.,
      423., 424., 425., 426., 429., 430., 431., 432., 437., 438., 439., 440.,
      441., 442., 443., 444., 487., 488., 489., 490., 493., 494., 495., 496.,
      501., 502., 503., 504., 505., 506., 507., 508., 551., 552., 553., 554.,
      557., 558., 559., 560., 565., 566., 567., 568., 569., 570., 571., 572.,
      583., 584., 585., 586., 589., 590., 591., 592., 597., 598., 599., 600.,
      601., 602., 603., 604., 695., 696., 697., 698., 701., 702., 703., 704.,
      709., 710., 711., 712., 713., 714., 715., 716., 743., 744., 745., 746.,
      749., 750., 751., 752., 757., 758., 759., 760., 761., 762., 763., 764.,
      807., 808., 809., 810., 813., 814., 815., 816., 821., 822., 823., 824.,
      825., 826., 827., 828., 871., 872., 873., 874., 877., 878., 879., 880.,
      885., 886., 887., 888., 889., 890., 891., 892., 903., 904., 905., 906.,
      909., 910., 911., 912., 917., 918., 919., 920., 921., 922., 923., 924.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  137., 138., 139., 140.,
      145., 146., 147., 148., 201., 202., 203., 204., 209., 210., 211., 212.,
      393., 394., 395., 396., 401., 402., 403., 404., 457., 458., 459., 460.,
      465., 466., 467., 468., 521., 522., 523., 524., 529., 530., 531., 532.,
      713., 714., 715., 716., 721., 722., 723., 724., 777., 778., 779., 780.,
      785., 786., 787., 788., 841., 842., 843., 844., 849., 850., 851., 852.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5,  19.,  21.,  23.,  24.,  32.5,  34.,  36.,  38.,  39.,
      52.5,  54.,  56.,  58.,  59.,  72.5,  74.,  76.,  78.,  79.,
      82.5,  84.,  86.,  88.,  89.,  117.5, 119., 121., 123., 124.,
      132.5, 134., 136., 138., 139., 152.5, 154., 156., 158., 159.,
      172.5, 174., 176., 178., 179., 182.5, 184., 186., 188., 189.,
      217.5, 219., 221., 223., 224., 232.5, 234., 236., 238., 239.,
      252.5, 254., 256., 258., 259., 272.5, 274., 276., 278., 279.,
      282.5, 284., 286., 288., 289.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23.,  25.,  27.,  43.,  45.,  47.,  63.,  65.,  67.,
      123., 125., 127., 143., 145., 147., 163., 165., 167.,
      223., 225., 227., 243., 245., 247., 263., 265., 267.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,  64.,  65.,
      67.,  68.,  71.,  72.,  75.,  76.,  77.,  78.,  104., 105., 107., 108.,
      111., 112., 115., 116., 117., 118., 144., 145., 147., 148., 151., 152.,
      155., 156., 157., 158., 164., 165., 167., 168., 171., 172., 175., 176.,
      177., 178., 234., 235., 237., 238., 241., 242., 245., 246., 247., 248.,
      264., 265., 267., 268., 271., 272., 275., 276., 277., 278., 304., 305.,
      307., 308., 311., 312., 315., 316., 317., 318., 344., 345., 347., 348.,
      351., 352., 355., 356., 357., 358., 364., 365., 367., 368., 371., 372.,
      375., 376., 377., 378., 434., 435., 437., 438., 441., 442., 445., 446.,
      447., 448., 464., 465., 467., 468., 471., 472., 475., 476., 477., 478.,
      504., 505., 507., 508., 511., 512., 515., 516., 517., 518., 544., 545.,
      547., 548., 551., 552., 555., 556., 557., 558., 564., 565., 567., 568.,
      571., 572., 575., 576., 577., 578.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  49.,  50.,  53.,  54.,  85.,  86.,  89.,  90.,  93.,
      94.,  125., 126., 129., 130., 133., 134., 245., 246., 249., 250.,
      253., 254., 285., 286., 289., 290., 293., 294., 325., 326., 329.,
      330., 333., 334., 445., 446., 449., 450., 453., 454., 485., 486.,
      489., 490., 493., 494., 525., 526., 529., 530., 533., 534.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, SAME3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,   68.,   69.,   70.,   73.,   74.,   75.,   76.,   81.,   82.,
      83.,   84.,   89.,   90.,   91.,   92.,   93.,   94.,   95.,   96.,
      127.,  128.,  129.,  130.,  133.,  134.,  135.,  136.,  141.,  142.,
      143.,  144.,  149.,  150.,  151.,  152.,  153.,  154.,  155.,  156.,
      207.,  208.,  209.,  210.,  213.,  214.,  215.,  216.,  221.,  222.,
      223.,  224.,  229.,  230.,  231.,  232.,  233.,  234.,  235.,  236.,
      287.,  288.,  289.,  290.,  293.,  294.,  295.,  296.,  301.,  302.,
      303.,  304.,  309.,  310.,  311.,  312.,  313.,  314.,  315.,  316.,
      327.,  328.,  329.,  330.,  333.,  334.,  335.,  336.,  341.,  342.,
      343.,  344.,  349.,  350.,  351.,  352.,  353.,  354.,  355.,  356.,
      467.,  468.,  469.,  470.,  473.,  474.,  475.,  476.,  481.,  482.,
      483.,  484.,  489.,  490.,  491.,  492.,  493.,  494.,  495.,  496.,
      527.,  528.,  529.,  530.,  533.,  534.,  535.,  536.,  541.,  542.,
      543.,  544.,  549.,  550.,  551.,  552.,  553.,  554.,  555.,  556.,
      607.,  608.,  609.,  610.,  613.,  614.,  615.,  616.,  621.,  622.,
      623.,  624.,  629.,  630.,  631.,  632.,  633.,  634.,  635.,  636.,
      687.,  688.,  689.,  690.,  693.,  694.,  695.,  696.,  701.,  702.,
      703.,  704.,  709.,  710.,  711.,  712.,  713.,  714.,  715.,  716.,
      727.,  728.,  729.,  730.,  733.,  734.,  735.,  736.,  741.,  742.,
      743.,  744.,  749.,  750.,  751.,  752.,  753.,  754.,  755.,  756.,
      867.,  868.,  869.,  870.,  873.,  874.,  875.,  876.,  881.,  882.,
      883.,  884.,  889.,  890.,  891.,  892.,  893.,  894.,  895.,  896.,
      927.,  928.,  929.,  930.,  933.,  934.,  935.,  936.,  941.,  942.,
      943.,  944.,  949.,  950.,  951.,  952.,  953.,  954.,  955.,  956.,
      1007., 1008., 1009., 1010., 1013., 1014., 1015., 1016., 1021., 1022.,
      1023., 1024., 1029., 1030., 1031., 1032., 1033., 1034., 1035., 1036.,
      1087., 1088., 1089., 1090., 1093., 1094., 1095., 1096., 1101., 1102.,
      1103., 1104., 1109., 1110., 1111., 1112., 1113., 1114., 1115., 1116.,
      1127., 1128., 1129., 1130., 1133., 1134., 1135., 1136., 1141., 1142.,
      1143., 1144., 1149., 1150., 1151., 1152., 1153., 1154., 1155., 1156.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride2Forward, VALID3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,   90.,   91.,   92.,   97.,   98.,   99.,   100.,  105.,  106.,
      107.,  108.,  169.,  170.,  171.,  172.,  177.,  178.,  179.,  180.,
      185.,  186.,  187.,  188.,  249.,  250.,  251.,  252.,  257.,  258.,
      259.,  260.,  265.,  266.,  267.,  268.,  489.,  490.,  491.,  492.,
      497.,  498.,  499.,  500.,  505.,  506.,  507.,  508.,  569.,  570.,
      571.,  572.,  577.,  578.,  579.,  580.,  585.,  586.,  587.,  588.,
      649.,  650.,  651.,  652.,  657.,  658.,  659.,  660.,  665.,  666.,
      667.,  668.,  889.,  890.,  891.,  892.,  897.,  898.,  899.,  900.,
      905.,  906.,  907.,  908.,  969.,  970.,  971.,  972.,  977.,  978.,
      979.,  980.,  985.,  986.,  987.,  988.,  1049., 1050., 1051., 1052.,
      1057., 1058., 1059., 1060., 1065., 1066., 1067., 1068.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
